Objects

尽管 ECMAScript 包含了定义类的语法，但是 ECMAScript 对象从根本上来说并不是像 C++，Smalltalk，Java 那样基于类的。相反，对象可以通过各种方式创建，包括字面符号，或通过构造器创建对象然后运行代码初始化其全部或部分属性值，为这些属性分配初始值。每个构造器是一个拥有名为 `"prototype"` 的属性的函数，此属性用于实现基于原型的继承 和共享属性。构造器通过 new 表达式创建对象：例如,`new Date(2009, 11)` 创建一个新 Date 对象。不使用new调用一个构造器的结果由构造器本身决定。例如，`Date()`产生一个表示当前日期时间的字符串，而不是一个对象。

每个由构造器创建的对象，都有一个隐式引用(叫做对象的原型)链接到构造器的 `"prototype"` 属性值。再者，一个原型可能有一个非空隐式引用链接到它的原型，以此类推，这叫做原型链。当向对象的一个属性提出引用时，引用会指向原型链中包含此属性名的第一个对象的属性。换句话说，首先检查直接提及的对象的同名属性，如果对象包含同名的属性，引用即指向此属性，如果该对象不包含同名的属性，则下一步检查对象的原型；以此类推。

一般情况下基于类的面向对象语言的实例拥有状态，类拥有方法，并且只能继承结构和行为。在 ECMAScript 中，对象拥有状态和方法，并且结构，行为，状态全都可继承。

所有不直接包含特定属性的对象会共享他们原型中包含的此属性及属性值。图 1 说明了这一点：

CF 是一个构造器（也是一个对象）。五个对象已用 `new` 表达式创建: cf₁, cf₂, cf₃, cf₄, cf₅。每个对象都有名为 `q1` 和 `q2` 的属性。虚线表示隐式原型关系；例如：cf₃ 的原型是 CF_p。构造器 CF 自己有名为 `P1` 和 `P2` 的两个属性, 这对 CF_p,cf₁, cf₂, cf₃, cf₄, cf₅ 是不可见的。CF_p 的名为 `CFP1` 的属性共享给 cf₁, cf₂,cf₃, cf₄, 以及 cf₅ ( 没有CF), 以及在 CF_p 的隐式原型链中找不到任何名为 `q1`, `q2`,或 `CFP1` 的属性。请注意，CF 和 CF_p 之间没有隐式原型链接。

不同于基于类的对象语言，属性可以通过赋值的方式动态添加给对象。也就是说，构造器并不是非要对构造的对象的全部或任何属性命名或赋值。上图中，可以给 CF_p 添加新属性值的方式为 cf₁, cf₂, cf₃, cf₄,and cf₅ 添加一个新的共享属性。

尽管 ECMAScript 对象本质上不是基于类，但是基于构造函数，原型对象和方法通用模式来实现类似于类的抽象是很方便的。ECMAScript 内置对象本身即遵循这样的类模式。从 ECMAScript 2015 开始，ECMAScript 语言包含了类定义语法，允许程序员像内置对象那样简洁的定义对象。

ECMAScript 严格变体

ECMAScript 语言认识到有的开发者可能希望限制使用语言中的新特性。他们这样做可能是为了安全考虑，避免他们认为是容易出错的功能，获得增强的错误检查，或其他原因。因此，ECMAScript 中定义了语言的严格变体。语言的严格变体，排除了 ECMAScript 语言的某些特定的语法和语义特征，还修改了某些功能的详细语义。严格变体还指定了必须抛出错误异常报告的额外错误条件，即使在非严格的语言形式下这些条件不属于错误。

ECMAScript 的严格变体通常被称为语言的严格模式。严格模式选择和使用明确地适用于独特 ECMAScript 代码单元级别的，ECMAScript 严格模式语法和语义。由于语法代码单元级别的严格模式被选择，严格模式仅在这个代码单元内施加有局部效果的限制。严格模式不限制或修改任何层面的 ECMAScript 语义，必须一致地操作跨多个代码单元。一个 ECMAScript 程序可同时包含严格模式和非严格模式的代码单元。在这种情况下，严格的模式只适用于严格模式代码单元内实际执行的代码。

要符合这一规范，ECMAScript 的实现必须同时实现未限制的 ECMAScript 语言和按照这个规范定义的 ECMAScript 的严格模式变体。此外，实现还必须支持未限制的和严格模式代码单元的在同一个程序中混用。

类型

在本规范中定义的数据值集合。

原始值

指在中定义的 Undefined, Null, Boolean, Number, Symbol, String 类型之一

对象

Object 类型的成员

构造函数

创建和初始化对象的函数对象

原型

为其他对象提供共享属性的对象

普通对象

默认行为拥有如那些所有对象都必须支持的内部方法的对象

异常对象

默认行为缺少一个或多个必要内部方法的对象

标准对象

其语义由本规范定义的对象

内置对象

ECMAScript 实现指定和提供的对象

未定义的值

一个在变量没有被赋值时就被使用的原始值

Undefined 类型

值只有 *undefined* 值的类型

空值

表示故意缺省任何对象值的原始值

Null 类型

值只有 *null* 值的类型

Boolean 值

Boolean 类型的成员

Boolean 类型

由原始值 *true* 和 *false* 组成的类型

Boolean 对象

标准内置构造函数 *Boolean* 的实例，Object 类型成员之一

String 值

由零个或多个16位无符号整数组成的有限有序序列原始值

String 类型

所有可能的 String 值的集合

String 对象

标准内置构造器 `String` 实例，Object 类型成员之一

Number 值

IEEE 754-2008 格式的 64 位双精度二进制的原始值

Number 类型

所有可能的 Number 值的集合，包括特殊 “Not-a-Number” (NaN) 值, 正无穷, 负无穷

Number 对象

标准内置构造器 `Number` 的一个实例，Object 类型成员之一

无穷

正无穷数值

NaN

值 IEEE 754-2008 “Not-a-Number” 的数值

Symbol 值

表示一个唯一的，非字符串的属性键对象的原始值

Symbol 类型

所有可能的 Symbol 值集合

Symbol 对象

标准内置构造器 `Symbol` 的一个实例，Object 类型成员之一

函数

可作为子程序调用的 Object 类型成员之一

内置函数

作为函数的内置对象

属性

将一个键（一个 String 值或 Symbor 值）和值相关联的对象的一部分

方法

作为属性值的函数

内置方法

作为内置函数的方法

特性

定义一个属性的一些特性的内部值

自身属性

对象直接拥有的属性

继承属性

不是对象的自身属性，但是是对象原型的属性(原型的自身属性或继承属性)

上下文无关文法

上下文无关文法由多个产生式组成。每个产生式左侧有一个称为非终结符的抽象符号的左值，右侧有一个或多个非终结符和终结符号组成的序列的右值。任何文法，它的终结符都来自指定的字母集。

一个产生式链是一个只含有一个非终结符以及 0 个或多个终结符作为其右值的产生式。

句子中单一可区分的非终结符——目标符，给定一个语言上下文无关文法。换句话说，重复用产生式右值替换序列中任何左值为非终结符所组成的终结符序列集合(可能是无限个)。

词法与正则文法

ECMAScript 词法文法在 给出。词法文法拥有符合 定义的 |SourceCharacter| 规则的终结符 Unicode 码点。它定义了一套产生式，从目标符 |InputElementDiv|, |InputElementTemplateTail|,或 |InputElementRegExp|, |InputElementRegExpOrTemplateTail| 起始，描述如何将这样的字符序列翻译成一个输入元素序列。

空白和注释之外的输入元素构成 ECMAScript 语法文法的终结符，它们被称为 ECMAScript tokens。这些 tokens 是，ECMAScript 语言的保留字，标识符，字面量，标点符号。此外，行结束符虽然不被视为 tokens，但会成为输入元素流的一部分，用于引导处理自动插入分号()。单个空白和单行注释会的丢弃，不会出现在语法文法的输入元素的流中。如果一个 |MultiLineComment|（即形式为 `/*`…`*/` 的注释，不管是否跨越多行）不包含行结束符也会直接地丢弃，但如果一个 |MultiLineComment| 包含一个或多个结束符，那么，注释会被替换为一个行结束符，成为语法文法输入元素流的一部分。

给出了 ECMAScript 的正则文法。此文法的终结符字符也由 |SourceCharacter| 定义。它定义了一套产生式，从目标符 |Pattern| 起始，描述了如何将这样的字符序列翻译成一个正则表达式模式。

两个冒号 "::" 作为分隔符分割词法和正则的文法产生式。词法和正则的文法共享某些产生式。

数字字符串文法

用于转换字符串为数字值的一种文法。此文法与数字字面量词法文法的一部分类似，并且有终结符 |SourceCharacter|。此文法出现在 。

三个冒号 ":::" 作为分隔符分割数字字符串文法的产生式。

语法文法

第 11，12，13，14，15 章给出了 ECMAScript 的语法文法。词法文法定义的 ECMAScript tokens 是此文法的终结符()。它定义了一系列的产生式，从两个可选的目标符号 |Script| 以及 |Module| 开始，描述了形成 ECMAScript 程序语法上正常的独立的组件的 token 是怎样的序列。

当一个码点流解析成一个 ECMAScript 的 |Script| 或者 |Module| 时，它首先被词法文法程序转换成一个输入元素流；然后使用一个单一语法文法程序解析这个输入元素流。存在语法错误 —— 输入元素流中的 token 不能被解析成一个单一的目标非终结符（|Script| 或者 |Module|）—— 的输入流，将不会留下任何 token。

当一个解析成功的时候，它会构造一颗解析树，一颗根树结构是它的每个节点都是一个 Parse Node。每个 Parse Node 都是文法中的一个符号的一个实例。它代表了从这样的符号中派生出来的源代码文本的一个跨度。解析树的根节点代表着整个的源代码文本，是解析的目标符的一个实例。当一个 Parse Node 是一个非终结符的实例的时候，它也是某些左值为非终结符的产生式的一个实例。此外，它有 0 个或多个孩子，产生式右值中的每个符号：每个孩子的 Parse Node 都是相应符号的一个实例。

新的 Parse Nodes 在每次调用解析器时都会被重新实例化，也就是说解析相同源文本也永远不会重用。当且仅当它们表示相同的源文本范围，是相同语法符号的实例，并且是由调用相同的解析器产生的解析节点时被认为是相同的 Parse Node

eval(str); eval(str);

只用一个冒号 “:” 作为分隔符分割语法词法的产生式。

语法文法在条款 12，13，14，15 中提出。但是对于哪些 token 序列是正确被 ECMAScript |Script| 或者 |Module| 接受的解释得并不完整。一些额外的 token 序列也能被接受，换句话说，那些序列将会被文法描述，只要分号被加入到序列中的某些地方（比如在行终结符之前）。此外，某些通过文法描述的 token 序列不会被接受，如果一个行终结符出现在某些 “awkward” 的地方。

在某些情况下，为了避免歧义，语法文法使用广义的产生式，允许 token 序列形成一个不合法的 ECMAScript |Script| 或者 |Module|。例如，此技术被用作对象字面量和对象解构模式中。在这种情况下，提供了更加限制性的补充文法，其进一步限制可接受的 token 序列。通常，如果 "_P_ is not covering an _N_"，则一个早期错误规则将会定义一个错误条件，其中 _P_ 是 Parse Node（普通产生式的一个实例），_N_ 是补充文法的非终结符。这里，最初与 _P_ 匹配的 token 序列被再次用 _N_ 作为目标符号解析。（如果 _N_ 使用语法参数，则将它们设置为当 _P_ 最初解析时使用的相同值）。如果 token 序列不能被解析为 _N_ 的一个单一实例，则会产生错误，将不会留下任何 token。随后，算法访问 "the _N_ that is covered by _P_" 的短语的解析结果。这将始终是一个解析节点（_N_ 的一个实例，对于一个给定的 _P_ 是唯一的），因此任何解析失败都将被一个早期错误规则检测到。

文法标记法

不管是在文法的产生式，还是在本规范中，词法文法，正则文法以及数字字符串文法的终结符都用等宽字体展示。这些将以的脚本形式出现。所有通过这种方式指定的终结符码点都被当作合适的基本拉丁语 Unicode 码点理解，而不是来自其他任何类似 Unicode 范围的码点。

非终结符以斜体显示。非终结符（也叫产生式）的定义由非终结符名称和其后定义的一个或多个冒号给出。（冒号的数量表示产生式所属的文法。）非终结符的一个或多个替代右值紧跟在下一行。例如，语法定义：

表示这个非终结符 |WhileStatement| 代表 `while` token，其后跟左括号 `token`，其后跟 |Expression|，其后跟右括号 `token`，其后跟 |Statement|。这里出现的 |Expression| 和 |Statement| 本身是非终结符。另一个例子，语法定义：

表示这个 |ArgumentList| 可以代表一个 |AssignmentExpression|，或 |ArgumentList|，其后跟一个逗号，其后跟一个 |AssignmentExpression|。这个 |ArgumentList| 的定义是递归的，也就是说，它定义它自身。其结果是，一个 |ArgumentList| 可能包含用逗号隔开的任意正数个参数，每个参数表达式是一个 |AssignmentExpression|。这样，非终结符共用了递归的定义。

终结符或非终结符可能会出现后缀下标 “_opt”，表示它是可选符号。包含可选符号实际指定了包含两个右值，一个是省略可选元素的，另一个是包含可选元素的。这意味着：

是以下的一种简便的缩写：

以及:

是以下的一种简便的缩写:

也是下面的一种缩写:

所以在这个例子中，非终结符 |IterationStatement| 实际上有四个可供选择的右值。

产生式可以通过形如 “_[parameters]” 这样的下标注释被参数化，会以后缀的形式出现在产生式定义的非终结符中。“_parameters” 可以是单独的名称，也可以是一个逗号分隔的名称列表。被参数化的产生式是一系列定义参数名称以下划线开头，追加到参数化的非终结符后面的所有组合的产生式的缩写。这就意味着：

是下面的缩写:

以及:

是下面的缩写:

多个参数产生数个产生式的组合，在一个完整语法中不必引用所有。

对生产式的非终结符右值的引用也可以被参数化，例如：

是下面的缩写:

又如:

是下面的缩写:

非终结符引用可能同时具有参数列表和一个 “_opt” 后缀。例如：

是下面的缩写:

在右侧非终结符引用参数名称前置以 “_?”，使该参数值取决于当前产生式的左侧符号引用的参数名称是否出现。例如：

是下面的缩写:

如果右值选择是以 “[+parameter]” 作为前缀，则表示选择只有命名参数用于引用产生式的非终结符时可用。如果右值选择是以 “[\~parameter]” 作为前缀，则表示选择只有命名参数不是用于引用产生式的非终结符时可用。这意味着:

是下面的缩写:

另外一个例子:

是下面的缩写:

在文法定义中当单词 “one of” 跟随一个或多个分号后的时候，表示随后的一行或多行的终结符是一个可选的定义。例如，ECMAScript的词法文法包含下列的产生式：

它仅仅是下面的缩写:

如果 “[empty]” 出现在一个产生式的右值，它暗示着这个产生式的右值不包含终结符或者非终结符。

如果 “[lookahead ∉ _set_]” 出现在一个产生式的右值，它暗示着如果随后立即的输入的token序列是给出的集合（_set_）的成员，那么这个产生式也许不会被使用。这个集合可以用一个逗号分割的由一到两个被花括号包裹的元素终结序列的列表表示。为了方便，这个集合也可以用非终结符表示，在这种情况下，它代表所有能由非终结符展开得到的终结符的集合。如果这个集合包含一个单独的终结符，那么短语 “[lookahead ≠ _terminal_]” 也许会被使用。

例如，给出定义:

则定义:

能匹配字母 n 后跟随由偶数起始的一个或多个十进制数字，或一个十进制数字后面跟随一个非十进制数字。

类似的，如果产生式的右值出现 “[lookahead ∈ _set_]”，则表示产生式只有在随后立即的输入的token序列是给出的集合（_set_）的成员才能使用。如果集合只包含一个单一的终结符，则可以使用 “[lookahead == _terminal_]”。

如果产生式的右侧出现 “[no |LineTerminator| here]”，那么它表示此产生式是个受限的产生式：如果 |LineTerminator| 在输入流的指定位置出现，那么此产生式将不会被适用。例如，产生式：

如果一个 |LineTerminator| 出现在脚本的 `throw` token 和 |Expression| 之间的时候，暗示着这个产生式也许不会被使用。

除非通过一个受限的产生式禁止一个 |LineTerminator| 的出现，否则任意数量 |LineTerminator| 的出现也许会发生在输入元素流中任意两个连续的 token 之间，并且不影响脚本的语义可接受性。

当一个词法文法或者数字字符串文法的产生式中可选部分出现多码点的 token 时，意味着码点序列将会组成一个 token。

一个产生式的右值也许会通过 “but not” 指定某些不被允许的扩展，然后暗示这个扩展将是被排除在外的。例如，产生式：

意味着非终结符 |Identifier| 也许会被任意的码点序列替换，这些码点能够替换提供的 |IdentifierName|，但是相同序列的码点不能替换 |ReservedWord|。

最后，一些非终结符通过 sans-serif 字体书写的描述性的短语来描述， 在这样的案例中，列出所有的可选部分是不切实际的。

抽象操作

为了便于它们在本规范的多个地方使用，一些算法，我们称之为抽象操作，以参数化函数形式命名和书写，以便它们能够在其它算法中通过名称来引用。抽象操作通常使用函数应用风格被引用，如 OperationName(_arg1_, _arg2_)。一些抽象操作被当作像类规范里抽象的多态发送一样。这样的类似类的方法抽象操作通常通过一个方法应用风格被引用，如 _someValue_.OperationName(_arg1_, _arg2_)。

语法导向操作

一个语法导向操作是一个具名操作，它的定义包含了一系列算法，每个算法与一个或者多个 ECMAScript 文法的产生式相关联。一个有多个可选定义的产生式通常对于每个可选部分都有一个独立的算法。当一个算法与一个文法产生式相关联的时候，它也许会引用这个产生式可选部分的终结符或者非终结符，就好像它们是这个算法的参数一样。当出现这种情况时，非终结符指向实际的源代码中与之匹配的可选部分的定义。

当一个算法与一个产生式的可选部分关联的时候，这个可选部分通常不会带上 “[ ]” 文法注释。这样的注释只应该影响可选部分的语法识别，不应该对相关的可选部分的语义有影响。

语法导向操作同一个解析节点一起被调用，还可以在以下算法步骤 1，3，4 中使用这个约定的其它参数:

除非另有明确说明，否则，所有相关联的产生式对于每个也许会被应用到这个产生式左值的非终结符的操作都有一个隐式的定义。如果存在的话，这个隐式的定义简单地再次对同样的参数运用这个相同的定义，对于这些相关联的产生式唯一的右值非终结符，随后返回处理结果。例如，假设一些算法有如下形式的步骤： “Return the result of evaluating |Block|”，并且这里有一个产生式：

但是解析操作并没有关联这个产生式的算法。那么在这样的案例中，解析操作隐式地包含了下面形式的关联：

运行时语义: 解析

运行时语义

必须在运行时被调用的指定语义的算法就叫运行时语义。 运行时语义通过抽象操作或者指定语法操作来定义。这样的算法必须返回一个完成记录。

静态语义

上下文无关文法不能足够好的去表达所有定义的规则，不管是一个输入元素的流形成的一个合法的将被解析的 ECMAScript |Script| 还是 |Module|。在一些情况中，需要额外的规则通过使用 ECMAScript 算法约定或者散文要求来展示。这样的规则总是与一个文法的产生式相关联，被称作产生式的静态语义。

静态语义规则拥有名称，并且通常用一个算法来定义。具有名称的静态语义规则与文法产生式相关联，对于每个可采用的具有名称的静态语义规则， 一个包含多个可选部分定义的产生式通常会对每个可选部分定义一个独有的算法。

除非在本规范中其它指定的文法产生式可选部分隐式地包含一个叫做 Contains 的接收一个值为包含相关产生式的文法的终结符或者非终结符的 _symbol_ 参数静态语义规则的定义。 默认的包含定义为：

上面的定义是显式地重写了规范的产生式。

一个特殊的静态语义规则是早期（提前）错误规则。早期错误规则定了早期错误条件（见 ），它们与具体的文法产生式相关联。大多数早期错误规则的解析不是在本规范的算法中显式地被调用。一个符合规范的实现必须在第一次解析 |Script| 或者 |Module| 之前，验证所有被用作解析 |Script| 或者 |Module| 的产生式的早期错误规则。如果违反了任意的早期错误规则，那么 |Script| 或者 |Module| 就是不合法的，并且不能被解析执行。

数学操作

除非其它地方特别注明不包括无限并且不包括负 0（为了与正 0 区分），数学操作，例如加，减，否定（逻辑非），乘，除以及随后在条款中定义的数学函数应总是被当作是对于数学中所有真实数字计算出来的准确的结果。本规范算法中的浮点运算包含显式地的步骤，它们对于处理无穷，有符号的0，以及舍入是必要的。如果一个数学操作或者函数被应用在一个浮点数上，那么它必须被当作应用到用浮点数表示的具体的数学值；这样的浮点数必须是有限的，并且如果它是 *+0* 或者 *-0* 的话，那么相应的数学值就是简简单单的 0。

数学函数 abs(_x_) 用来计算 _x_ 的绝对值，如果 _x_ 是负数，那么结果就是 -_x_，否则结果就是 _x_ 本身。

数学函数 min(_x1_, _x2_, ..., _xN_) 计算从 _x1_ 到 _xN_ 的最小值。 数学函数 max(_x1_, _x2_, ..., _xN_) 计算从 _x1_ 到 _xN_ 的最大值。 这些数学函数的域以及范围包括 *+∞* 和 *-∞*。

符号 “_x_ modulo _y_” （ _y_ 必须是有限的且是非 0 的）计算出一个值 _k_， 它的符号与 _y_ 一致（或者是 0），这样的 _k_ 满足 abs(k) < abs(y)，以及能找到某个整数y，使得 _x_-_k_ = _q_ * _y_。

数学函数 floor(_x_) 产生一个不大于 _x_ 的最大整数（最接近正无穷）。

Undefined 类型

Undefined 类型仅仅只有一个值，`undefined`。 任何尚未分配值的变量值都为 `undefined`。

Null 类型

Null 类型只有一个值, `null`.

Boolean 类型

Boolean 类型表示具有 `true` 和 `false` 两个值的一个逻辑实体。

String 类型

String 类型是零个或多个 16 位无符号整数值（“元素”）的所有有序序列的集合，最大长度为 2⁵³-1 个元素。字符串类型通常用于表示正在运行的 ECMAScript 程序中的文本数据，在这种情况下，String中的每个元素都被视为一个 UTF-16 码元。 每个元素被认为占据该序列内的一个位置。 这些位置用非负整数索引。 第一个元素（如果有）在索引 0 处，下一个元素（如果有的话）在索引 1 处，以此类推。 String 的长度是序列中的元素个数（例如，十六位值）。空字符串的长度为零，因此不包含元素。

ECMAScript 操作符不应用不同的语义解释字符串内容。操作符把字符串的每个元素视为单个 UTF-16 代码单元进行解释。但是，ECMAScript 并不约束这些代码单元的值或这些代码单元之间的关系，因此进一步将字符串内容解释为 UTF-16 中编码的 Unicode 代码点序列的操作必须考虑格式不对的子序列。此类操作使用如下规则对每个代码单元特殊处理，使其数值范围在 0xD800 到 0xDBFF（Unicode 标准定义为 首代理，或者更正式的 高代理码元）或范围 0xDC00 到 0xDFFF（定义为尾代理，或者更正式的低代理码元）：

• 不是 也不是 的码元被解释为具有相同值的码点。
• 两个码元序列，其第一个码元 _c1_ 是一个 ，第二个码元 _c2_ 是一个 ， 这样的两个码元，被称为代理对， 被解释为一个值为 (_c1_ - 0xD800) × 0x400 + (_c2_ - 0xDC00) + 0x10000 的码点。(见 )
• 一个 或者 ，但不是一个的一部分的码元被解释为具有相同值的码点。

函数 `String.prototype.normalize` (see ) 可以显式地标准化一个字符串值. `String.prototype.localeCompare` (see ) 在内部规范化字符串值，但没有其他操作隐式规范化它们运行的字符串。只有明确指定为语言或区域设置敏感的操作才会生成对语言敏感的结果。

在本规范中，短语"the string-concatenation of _A_,_B_,..."表示字符串代码单元的序列是每个参数的代码单元的连接。

Symbol 类型

Symbol 类型是所有可以用于作为 Object 属性 key 值的非字符串值的集合。()。

每个可能的 Symbol 值都是唯一的和不可变的。

每个 Symbol 值永远地保持一个与之关联的叫做 [[Description]] 的值（它要么是 *undefined* 要么是一个 String 值）。

Number 类型

Number 类型有 18437736874454810627 (即，2⁶⁴-2⁵³+3)个值，表示双精度 64 位格式的 IEEE 754-2008 值由 IEEE 二进制浮点数标准规定，除了 9007199254740990 (即，2⁵³-2)这个在 IEEE 标准中独特的 “Not-a-Number” 值，其在 ECMAScript 中表示为一个特殊的 *NaN* 值。(注意 *NaN* 值在程序中由 *NaN* 表达式产生)在某些实现中，外部代码可能能够检测各种 Not-a-Number 值之间的差异，但这种行为依赖于实现; 对于 ECMAScript 代码，所有的 *NaN* 值彼此是不可区分。

还有另外两个特殊的值，叫做*正无穷*和*负无穷*。 为了简洁起见，这些值分别由符号 *+∞* 和 *-∞* 表示。（请注意，这两个无穷数值由程序表达式 *+Infinity*（或 *Infinity* ）和 *-Infinity* 产生。）

其他 18437736874454810624（即，2⁶⁴-2⁵³）个值称为有限值。 其中一半为正数，一般为负数；每个有限正数存在相同大小的对应负数。

注意其中有一个*正零*，一个*负零*。为了简洁，他们也分别用 *+0* 和 *-0* 来说明。（注意这两个不同的 0，通过程序表达式 *+0*(或 *0*) 和 *-0* 产生。）

18437736874454810622（即 2⁶⁴-2⁵³-2）个有限非 0 值有两种：

其中 18428729675200069632 (即 2⁶⁴-2⁵⁴) 个值是标准的, 具有如下格式

其中 _s_ 为 +1 或 -1，_m_ 是一个小于 2⁵³ 但大于等于 2⁵² 的整数，_e_ 是从 -1074 到 971 的整数。

其余 9007199254740990 (即 2⁵³-2) 个值是非标准的, 有如下格式

其中 s 是 +1 或 -1 ，m 是小于 52 的正整数，e 是 -1074。

注意，大小不大于 2⁵³ 的所有正整数和负整数可以在 Number 类型中表示（实际上，整数 0 具有两个表示，*+0* 和 *-0*）。

如果一个有限的数值非零且用来表达它（上文两种形式之一）的整数 m 是奇数，则该数值有奇数意义。否则，它有偶数意义。

在本规范中，当 _x_ 表示一个精确的非零实数数学量（甚至可以是无理数，比如π）时，“the Number value for _x_” 意为，以下面的方式选择一个 Number 值。考虑 Number 类型中除了 *-0* 和两个被加入在数值类型中但不可呈现的值，2¹⁰²⁴ (+1 × 2⁵³ × 2⁹⁷¹) 以及 -2¹⁰²⁴(-1 × 2⁵³ × 2⁹⁷¹)的所有有限值的集合。选择此集合中值最接近 _x_ 的一员。若集合中的两值近似相等，那么选择有偶数意义的那个；为此，2¹⁰²⁴和-2¹⁰²⁴这两个超额值被认为有偶数意义。最终，若选择 2¹⁰²⁴ ，用 *+∞* 替换它；若选择 -2¹⁰²⁴， 用 *-∞* 替换它；若选择 *+0*，有且只有 _x_ 小于零时，用 *-0* 替换它；其它任何被选取的值都不用改变。结果就是 _x_ 的 Number 值。（此过程正是IEEE 754-2008“round to nearest, ties to even”模式对应的行为。）

某些 ECMAScript 运算符仅处理闭区间 -2³¹ 到 2³¹-1，或者 0 到 2¹⁶-1 的整数。 这些操作符接收任意 Number 类型的值，首先会将它们转换成像上面提到的这些范围内的值。参考的数字转换操作。

Object 类型

对象在逻辑上是属性的集合。每个属性都是一个数据属性或一个访问器属性：

• 数据属性关联 key 值和一个 ECMAScript 语言值以及一组值为 Boolean 类型的特性。
• 访问器属性关联 key 值和一个或两个访问器函数以及一组值为 Boolean 类型的特性。访问器函数用于存储或检索与该属性相关联的 ECMAScript 语言值。

属性使用 key 值来标识。一个属性的 key 值是 ECMAScript String 值或 Symbol 值。所有 String 值（包括空字符串） 和 Symbol 值作为属性的 key 都是有效的。属性名称是指属性的 key，其值为字符串。

一个值为 `+0` 或者一个 ≤ 2⁵³-1 的整数作为属性 key 字符串值的数字索引是一个以典型的数字 String（见 ）。一个数组索引是范围在 +0 ≤ _i_ < 2³²-1 的整数。

属性的 key 用来访问属性以及其值。属性有两种访问方式：get 和 set ，分别对应值的检索和赋值。通过 get 和 set 可访问的属性既包括直接属于的自身属性，也包括通过继承关系由其它相关对象提供的继承属性。继承属性也可能是另一个对象的自身属性或者继承属性。对象的每个自身属性必须有一个与对象的其他自身属性 key 值不同 key 值。

所有的对象都是逻辑上的属性集合，但是在用于访问和操纵它们的属性的语义中存在多种形式的对象。普通对象是对象的最常见形式，拥有默认的对象语义。奇异对象是指其属性语义与默认语义的各个方面都有区别的对象。

List 以及 Record 规范类型

List 类型用来解释在 `new` 表达式，函数调用，以及其它需要一个简单的有序的值的 list 的算法中的参数列表(见)的求值，List 类型的值是包含单个值的列表元素的简单有序序列。这些序列可能是任意长度。列表的元素可以通过使用从 0 开始的索引随机访问。为了方便起见，可以使用类似数组的语法来访问 List 元素。 例如，_arguments_[2] 简短的表示 _arguments_ List 的第三个元素。

在规范中为了方便，一个字面量语法被用来表达一个新 List 值。 如 « 1, 2 » 定义一个新 List 值，它拥有两个元素，每个元素被初始化为一个特定的值。一个空的 List 值可以用 « » 表示。

Record 类型用来描述在该规范中的算法内的数据聚合。一个 Record 类型值包含一个或多个命名字段。每个字段的值是一个 ECMAScript 值或者通过由与 Record 类型相关联的名称代表的抽象值。字段名称始终用双括号括起来，例如 [[Value]]。

在规范中为了方便，使用类似对象字面量的语法来表示一个 Record 值。 如 { [[Field1]]: 42, [[Field2]]: `false`, [[Field3]]: ~empty~ } 定义一个拥有3个字段的 Record 值。每个字段被初始化为一个特定的值。字段名称顺序不重要。任何未明确列出的字段都被视为不存在。

在规范文本和算法中，点记号可以用于指代记录值的特定字段。例如，如果 R 是上一段所示的记录，则 R.[[Field2]] 是 “R 中名称为 [[Field2]] 的字段 ” 的缩写。

应该命名常用记录字段组合的模式， 并且该名称可以用作Record字面量的前缀，以标识特定类型聚合的描述。 例如：PropertyDescriptor { [[Value]]: 42，[[Writable]]: `false`，[[Configurable]]: `true` }。

Set 和 Relation 规范类型

Set 类型被用来解释在内存模型中无序元素的集合。Set 类型的值是简单的元素的集合，其中没有任何元素出现超过一次。元素可以从 Set 中添加或者删除。不同的 Set 可以合并，相交或者相减。

Relation 类型被用来解释在 Set 上的约束。一个关系类型的值是它的的值域中有序对的集合。例如，一个在 event 上的关系是一个有序的的 event 对的集合。对于一个关系 _R_ 以及在 _R_ 的值域中的两个值 _a_ 和 _b_，_a_ _R_ _b_ 是有序对 (_a_, _b_) 是 _R_ 的成员的简写。当 Relation 满足这些条件的最小 Relation 时，Relation 对于某些条件是最小的。

严格偏序是指一个 Relation 值 _R_ 满足如下条件。

• 对于_R_值域中的 _a_，_b_，_c_：

  • _a_ _R_ _a_ 不成立，且
  • 如果 _a_ _R_ _b_ 并且 _b_ _R_ _c_ 成立，那么 _a_ _R_ _c_ 成立。

严格全序是指一个 Relation 值 _R_ 满足如下条件。

• _R_ 值域中的 _a_，_b_，_c_：

  • _a_ 全等于 _b_ 或 _a_ _R_ _b_ 或 _b_ _R_ _a_，且
  • _a_ _R_ _a_ 不成立，且
  • 如果 _a_ _R_ _b_ 同时 _b_ _R_ _c_，那么 _a_ _R_ _c_。

Completion Record 规范类型

Completion 类型是一个用来解释运行时数值和控制流传播的 Record，如执行非局部转移控制语句(`break`，`continue`，`return` 和 `throw`)的行为。

Completion 类型值是字段名为表中的Record值。这些值被称为Completion Record。

术语 “异常结束” 是指 [[Type]] 值为除 ~normal~ 之外的值。

Reference 规范类型

一个 Reference 是一个解析后的名称或者属性组合。一个 Reference 包含3个组件，基值组件，引用名组件，以及一个 Boolean 值的严格引用标志。一个基值组件可以是 *undefined*，Object， Boolean，String，Symbol，Number, 或 Environment Record。一个基值组件为 *undefined* 表示 Reference 解析为一个组合。引用名组件是一个 String，或 Symbol。

一个 Super Reference 是指，用于表示使用 super 关键字表示一个名称组合的 Reference。一个 Super Reference 有一个额外的 thisValue 组件，且他的基值组件永远不会是一个 Environment Record。

以下抽象操作在本规范中用于操作引用：

Property Descriptor 规范类型

Property Descriptor 类型用来解释对象属性的特性的操作和具体化。Property Descriptor 的值为 Record 类型。每个字段的名称都是一个特性名称，其值是 相应的特性值。另外，任何字段都可以存在或不存在。在本规范中用于标记 Property Descriptor 记录的字面量描述是 “PropertyDescriptor”。

Property Descriptor 值可以根据某些字段的存在或使用进一步分类为数据 Property Descriptor 和访问器 Property Descriptor。包含字段 [[Value]] 或 [[Writable]] 的是数据 Property Descriptor。包含字段 [[Get]] 或 [[Set]] 的是访问器 Property Descriptor。所有的 Property Descriptor 都可能包含 [[Enumerable]]，[[Configurable]] 字段名。一个 Property Descriptor 值可能不会同时为一个数据 Property Descriptor 和一个访问器 Property Descriptor。然而，也不一定，一个通用 Property Descriptor 是一个既不是数据 Property Descriptor 也不是访问器 Property Descriptor 的 Property Descriptor值。一个完全填充的 Property Descriptor 既是一个数据 Property Descriptor 也是一个访问器 Property Descriptor， 他有所有符合表 和 定义的属性特性字段。

在本规范中使用以下抽象操作用来操作 Property Descriptor值：

Lexical Environment 和 Environment Record 规范类型

Lexical Environment and Environment Record 是用来解释在嵌套的函数和块中的名称解析行为。这些类型以及他们的操作在 中定义。

Data Blocks

Data Block 规范类型用来描述不同且可变的字节(8 bit)大小的数字值序列。一个 Data Block 值由初始值为 0，固定数量的字节构成。

在本规范中为了方便，可以使用类似数组的语法来访问一个 Data Block 值的各个字节。这些符号将 Data Block 值的这些字节表示为一个从 0 开始的索引队列。 例如，如果 _db_ 是一个 5 字节的 Data Block 值，那么 _db_[2] 可以用来访问第三字节。

驻留在内存中，可以被多个代理并发引用的数据块被称为 Shared Data Block。一个 Shared Data Block 有一个 空地址 的标识（目的是平等检测 Shared Data Block 值）： 它不依赖于所述块在任何进程中映射到的虚拟地址，而是用该块来表示内存中的位置集合。只有当两个块包含的位置集合相等时他们才相等。否则，他们地址集合的交集为空，他们是不相等的。最后，可以从 Data Block 区分 Shared Data Blocks。

Shared Data Block 的语义由内存模型中的 Shared Data Block 事件来定义。下方的抽象操作介绍了 Shared Data Block 事件，以及在内存模型上解析语义和事件语义的接口的行为。事件形成了一个候选执行，内存模型扮演了一个过滤器的角色。请查看内存模型来了解完整的语义。

Shared Data Block 事件由 Record 建模, 通过内存模型定义。

下列抽象操作在本规范中用于对 Data Block 值进行操作：

ToPrimitive ( _input_ [ , _PreferredType_ ] )

抽象操作 ToPrimitive 接受一个 _input_ 参数和一个可选的 _PreferredType_ 参数。ToPrimitive 负责把 _input_ 参数转换为一个非对象类型。如果一个对象可以转换为多个原始类型，则应该根据可选提示 _PreferredType_ 来判断转换的类型。根据以下算法进行转换：

ToBoolean ( _argument_ )

抽象操作 ToBoolean 把参数 _argument_ 转换为一个 Boolean 类型的值，见表 ：

ToNumber ( _argument_ )

抽象操作把 _argument_ 转换为一个 Number 类型的值，转换结果见表 ：

ToInteger ( _argument_ )

抽象操作 ToInteger 把 _argument_ 转换为整数数值。这个抽象操作算法如下：

ToInt32 ( _argument_ )

抽象操作 ToInt32 把 _argument_ 转换为范围为 -2³¹ 到 2³¹-1的 2³² 个整数之一,这个抽象操作算法如下：

ToUint32 ( _argument_ )

抽象操作 ToUint32 将 _argument_ 转换为 0 到 2³²-1 的 2³² 个整数之一。该抽象操作算法如下：

ToInt16 ( _argument_ )

抽象操作 ToInt16 将 _argument_ 转换为 -32768 到 32767 的 2¹⁶ 个整数之一。这个抽象操作算法如下：

ToUint16 ( _argument_ )

抽象操作 ToUint16 将 _argument_ 转换为 0 到 2¹⁶-1 的 2¹⁶ 个整数之一。这个抽象操作算法如下：

ToInt8 ( _argument_ )

抽象操作 ToInt8 负责将 _argument_ 转换为 -128 到 127 的 2⁸ 个整数之一。这个抽象操作算法如下：

ToUint8 ( _argument_ )

抽象操作 ToUint8 负责将 _argument_ 转换为 0 到 255 的 2⁸ 个整数之一。这个抽象操作算法如下：

ToUint8Clamp ( _argument_ )

抽象操作 ToUint8Clamp 负责将 _argument_ 转换为 0 到 255 的 2⁸ 个整数之一。这个抽象操作算法如下：

ToString ( _argument_ )

抽象操作 ToString 负责将 _argument_ 转换为一个 String 类型值，如下:

ToObject ( _argument_ )

抽象操作 ToObject 负责将 _argument_ 转换为 Object 类型的值，见表：

ToPropertyKey ( _argument_ )

抽象操作 ToPropertyKey 负责将 _argument_ 转换为一个可用作属性 key 的值，其步骤如下：

ToLength ( _argument_ )

抽象操作 ToLength 负责将 _argument_ 转换为一个可用作类数组的长度的整数，其步骤如下：

CanonicalNumericIndexString ( _argument_ )

如果 _argument_ 为是一可以通过 ToString 产生的数字字符串，或者是一个为 `"-0"` 的字符串，则抽象操作 CanonicalNumericIndexString 返回转换 _argument_ 得到的一个数字。否则，返回 `undefined`。这个抽象操作算法如下：

一个规范的数字字符串是指 CanonicalNumericIndexString 抽象操作返回值不为 *undefined* 的字符串。

ToIndex ( _value_ )

抽象操作 ToIndex 负责将 _value_ 参数转换为一个有效的整数索引值。这个抽象操作算法如下：

RequireObjectCoercible ( _argument_ )

抽象操作 RequireObjectCoercible 尝试使用 ToObject 将 _argument_ 转换为一个对象，如果转换失败，则抛出一个错误，成功则返回 _argument_。如下表中定义的：

IsArray ( _argument_ )

抽象操作 IsArray 接受一个参数 _argument_，他的执行步骤如下：

IsCallable ( _argument_ )

抽象操作 IsCallable 用于判断 _argument_ 是否为一个拥有 [[call]] 内部方法的可调用函数，_argument_ 必须是 ECMAScript 语言值。

IsConstructor ( _argument_ )

抽象操作 IsConstructor 用于判断 _argument_ 是否为一个拥有 [[Construct]] 内部方法的函数对象，_argument_ 必须是 ECMAScript 语言值。

IsExtensible ( _O_ )

抽象操作 IsExtensible 用于判断对象 _O_ 是否可以添加新的属性，返回一个 Boolean 值。该抽象操作的执行步骤如下：

IsInteger ( _argument_ )

抽象操作 IsInteger 用于判断 _argument_ 是否为一个有限整数数值。

IsPropertyKey ( _argument_ )

抽象操作 IsPropertyKey 用于判断 _argument_ 是否可用作为对象的属性的 key，_argument_ 必须是一个 ECMAScript 语言值。

IsRegExp ( _argument_ )

参数为 _argument_ 的抽象操作 IsRegExp 执行步骤如下：

IsStringPrefix ( _p_, _q_ )

抽象操作 IsStringPrefix 确定字符串 _p_ 是不是字符串 _q_ 的前缀。

SameValue ( _x_, _y_ )

内部比较抽象操作 SameValue(_x_, _y_) 返回 *true* 或 *false*，其中 _x_ 和 _y_ 都是 ECMAScript 语言值。它将执行比较如下：

SameValueZero ( _x_, _y_ )

内部比较抽象操作 SameValueZero(_x_, _y_) 返回 *true* 或 *false*，其中 _x_ 和 _y_ 都是ECMAScript语言值。 它将执行比较如下：

SameValueNonNumber ( _x_, _y_ )

内部比较抽象操作 SameValueNonNumber(_x_, _y_) 返回 *true* 或 *false*，其中 _x_ 和 _y_ 都是 Number 值。它将执行比较如下：

抽象关系比较

比较_x_ < _y_，_x_ 和 _y_ 都是 ECMAScript 语言值，将可能产生*true*, *false*, 或 *undefined*（表示其中至少有一个操作数为 *NaN*）。除了 _x_ 和 _y_ 之外，算法会使用一个名为 _LeftFirst_ 的 Boolean 类型标志，作为一个参数。这个标志用于控制对 _x_ 和 _y_ 执行潜在可见副作用操作的顺序。这是有必要的，因为 ECMAScript 规定计算是从左向右的。_LeftFirst_ 的默认值为 *true*，表示 _x_ 参数相应表达式在 _y_ 参数相应的表达式的左测。如果 _LeftFirst_ 为 *false*，则必须在 _x_ 之前执行 _y_。具体比较执行如下：

抽象相等比较

比较 _x_ == _y_，产生 *true*，*false*，其中 _x_ 与 _y_ 都是 ECMAScript 语言值。具体比较算法如下：

严格相等比较

比较 _x_ === _y_，产生 *true*，*false*，其中 _x_ 和 _y_ 都是ECMAScript语言值。具体比较算法如下：

Get ( _O_, _P_ )

抽象操作 Get 用于检索对象特定属性的值。该操作接受两个参数 _O_, _P_，其中 _O_ 是操作的对象，_P_ 是对象的属性 key。该抽象操作执行以下步骤：

GetV ( _V_, _P_ )

抽象操作 GetV 用于检索一个 ECMAScript 语言值指定属性的值。如果这个 ECMAScript 值不是对象，则使用合适该值类型的属性包装器对象来执行属性的查找。使用参数 _V_ 和 _P_ 调用操作([[Get]])，其中 _V_ 是传入的 ECMAScript 值，_P_ 是需要检索的属性 key。该抽象操作的执行步骤如下：

Set ( _O_, _P_, _V_, _Throw_ )

抽象操作 Set 用于设置对象的特定属性的值。该操作使用参数 _O_， _P_， _V_， _Throw_ 调用，其中 _O_ 是被操作的对象，_P_ 是制定的属性， _V_ 是属性的新值，_Throw_ 是一个 Boolean 类型的标志。该操作的执行步骤如下：

CreateDataProperty ( _O_, _P_, _V_ )

抽象操作 CreateDataProperty 用于给对象创建一个新的自身属性。这个操作使用参数 _O_， _P_ 和 _V_ 调用，其中 _O_ 是被操作的对象，_P_ 是属性 key 值，_V_ 是属性的值。这个抽象操作执行以下步骤：

CreateMethodProperty ( _O_, _P_, _V_ )

抽象操作 CreateMethodProperty 用于给对象创建一个新的自身属性。接受参数 _O_，_P_，_V_，其中 _O_ 是目标对象，_P_ 是属性 key，_V_ 是属性值。该操作的执行步骤如下：

CreateDataPropertyOrThrow ( _O_, _P_, _V_ )

抽象操作 CreateDataPropertyOrThrow 用于给对象自身添加一个新属性，如果更新属性的请求不能执行将抛出 *TypeError* 异常。接受参数 _O_，_P_，_V_，其中 _O_ 是目标对象，_P_ 是属性 key，_V_ 是属性值。该操作的执行步骤如下：

DefinePropertyOrThrow ( _O_, _P_, _desc_ )

抽象操作 DefinePropertyOrThrow 通过调用对象内部方法 [[DefineOwnProperty]] 的方式定义一个自身属性，如果更新属性的请求不能执行将抛出 *TypeError* 异常。该操作接受参数 _O_，_P_，_desc_，其中 _O_ 是目标对象，_P_ 是属性 key，_desc_ 是属性的 Property Descriptor。该操作的执行步骤如下：

DeletePropertyOrThrow ( _O_, _P_ )

抽象操作 DeletePropertyOrThrow 用于删除指定对象属性。如果属性是不可配置的将抛出（*TypeError*）异常。参数 _O_ 表示目标对象，_P_ 是指定需要删除的属性 key。该操作的执行步骤如下：

GetMethod ( _V_, _P_ )

抽象操作 GetMethod 用于从一个 ECMAScript 语言值获取指定属性的值，该值应该是一个函数。参数 _V_ 表示一个被操作的 ECMAScript 语言值，_P_ 表示指定的属性 key。该操作的执行步骤如下：

HasProperty ( _O_, _P_ )

抽象操作 HasProperty 用于确定一个对象是否拥有特定的属性。这个属性可以是自身的也可以是继承的。该抽象操作返回一个 Boolean 值。参数 _O_ 表示目标对象，_P_ 是指定的属性 key。该操作的执行步骤如下：

HasOwnProperty ( _O_, _P_ )

抽象操作 HasOwnProperty 用于确定对象自身是否拥有特定的属性。返回一个 Boolean 值。参数 _O_ 表示目标对象，_P_ 是指定的属性 key。该操作的执行步骤如下：

Call ( _F_, _V_ [ , _argumentsList_ ] )

抽象操作 Call 负责调用一个函数对象的 [[Call]] 内部方法。该操作接受一个函数对象 _F_，一个代表 [[Call]] 的 *this* 值的 ECMAScript 语言值 _V_，以及传递给内部方法的可选参数 _argumentsList_。如果 _argument_ 没提供，则默认使用一个空的 List。该操作的执行步骤如下：

Construct ( _F_ [ , _argumentsList_ [ , _newTarget_ ]] )

抽象操作 Construct 用于调用函数对象内部方法 [[Construct]]。该抽象操作使用参数 _F_, 可选参数 _argumentsList_, 以及可选参数 _newTarget_。 其中 _F_ 是一个函数对象. _argumentsList_ 和 _newTarget_ 是作为内部方法相应参数传递的值。 如果 _argumentsList_ 未提供则默认使用一个空 List 作为其值。如果 _newTarget_ 未提供，则使用 _F_ 作为其值。该抽象操作执行步骤如下：

SetIntegrityLevel ( _O_, _level_ )

抽象操作 SetIntegrityLevel 用于固定一个对象自身属性集合。 这个抽象操作执行步骤如下：

TestIntegrityLevel ( _O_, _level_ )

抽象操作 TestIntegrityLevel 用于检查对象自身属性是否被固定。这个抽象操作执行步骤如下：

CreateArrayFromList ( _elements_ )

抽象操作 CreateArrayFromList 用于创建一个数组对象，其元素由由一个 List 的参数提供。该抽象操作执行以下步骤：

CreateListFromArrayLike ( _obj_ [ , _elementTypes_ ] )

抽象操作 CreateListFromArrayLike 用于创建一个 List 值，其元素通过类数组对象 _obj_ 属性的索引提供。可选参数 _elementTypes_ 是一个包含 ECMAScript 语言类型的名称列表，表示被创建的 List 元素值被允许的类型。该抽象操作的执行步骤如下：

Invoke ( _V_, _P_ [ , _argumentsList_ ] )

抽象操作 Invoke 用于调用一个 ECMAScript 语言值的方法属性。该操作用参数 以及可选参数 _argumentsList_ 调用，其中 _V_ 即作为属性的查找点也作为调用的 `this` 值， _P_ 是属性 key， _argumentsList_ 是传递给方法的参数列表。 如果 _argumentsList_ 未提供，则使用一个空的 List 作为他的值。该抽象操作执行步骤如下：

OrdinaryHasInstance ( _C_, _O_ )

抽象操作 OrdinaryHasInstance 执行默认算法，确定对象 _O_ 是否继承自构找函数 _C_ 提供的实例对象继承路劲。该抽象操作执行步骤如下：

SpeciesConstructor ( _O_, _defaultConstructor_ )

抽象操作 SpeciesConstructor 用于检索用于创建新对象的构找函数，该新对象是从参数对象 _O_ 派生的。如果在对象 _O_ 属性中不能找到一个 constructor@@species 属性，则使用 _defaultConstructor_ 作为构造函数。该抽象操作的执行步骤如下：

EnumerableOwnPropertyNames ( _O_, _kind_ )

当使用对象 _O_ 和字符串 _kind_ 作为参数调用抽象操作 EnumerableOwnPropertyNames 时执行以下步骤：

GetFunctionRealm ( _obj_ )

参数为 _obj_ 的抽象操作 GetFunctionRealm 执行以下步骤：

CopyDataProperties ( _target_, _source_, _excludedItems_ )

When the abstract operation CopyDataProperties is called with arguments _target_, _source_, and _excludedItems_, the following steps are taken:

GetIterator ( _obj_ [ , _hint_ [, _method_ ] )

参数为 _obj_ 和可选参数 _hint_, _method_ 的抽象操作 GetIterator 执行以下步骤：

IteratorNext ( _iteratorRecord_ [ , _value_ ] )

参数为 _iteratorRecord_ 和可选参数 _value_ 的抽象操作 IteratorNext 执行以下步骤：

IteratorComplete ( _iterResult_ )

参数为 _iterResult_ 的抽象操作 IteratorComplete 执行以下步骤：

IteratorValue ( _iterResult_ )

使用参数为 _iterResult_ 的抽象操作 IteratorValue 执行以下步骤：

IteratorStep ( _iteratorRecord_ )

使用参数 _iteratorRecord_ 的抽象操作 IteratorStep 通过调用 _iteratorRecord_.[[NextMethod]] 从 _iteratorRecord_.[[Iterator]] 中请求 next 值，并返回 *false* 或一个 IteratorResult 对象。*false* 表示迭代结束，IteratorResult 对象是一个可用的 next 值。其执行步骤如下：

IteratorClose ( _iteratorRecord_, _completion_ )

参数为 _iteratorRecord_ 和 _completion_ 的抽象操作 IteratorClose 用于通知迭代器，它应该执行它在达到其完成状态时通常会执行的一些操作：

AsyncIteratorClose ( _iteratorRecord_, _completion_ )

The abstract operation AsyncIteratorClose with arguments _iteratorRecord_ and _completion_ is used to notify an async iterator that it should perform any actions it would normally perform when it has reached its completed state:

CreateIterResultObject ( _value_, _done_ )

参数为 _value_ 和 _done_ 的抽象操作 CreateIterResultObject 创建一个支持 IteratorResult 接口的对象，它执行以下操作：

CreateListIteratorRecord ( _list_ )

参数为 _list_ 的抽象操作 CreateListIteratorRecord 创建一个迭代器 () 对象记录，其 next 方法返回元素连续的 _list_。该抽象操作执行以下步骤：

Environment Records

There are two primary kinds of Environment Record values used in this specification: declarative Environment Records and object Environment Records. Declarative Environment Records are used to define the effect of ECMAScript language syntactic elements such as |FunctionDeclaration|s, |VariableDeclaration|s, and |Catch| clauses that directly associate identifier bindings with ECMAScript language values. Object Environment Records are used to define the effect of ECMAScript elements such as |WithStatement| that associate identifier bindings with the properties of some object. Global Environment Records and function Environment Records are specializations that are used for specifically for |Script| global declarations and for top-level declarations within functions.

For specification purposes Environment Record values are values of the Record specification type and can be thought of as existing in a simple object-oriented hierarchy where Environment Record is an abstract class with three concrete subclasses, declarative Environment Record, object Environment Record, and global Environment Record. Function Environment Records and module Environment Records are subclasses of declarative Environment Record. The abstract class includes the abstract specification methods defined in . These abstract methods have distinct concrete algorithms for each of the concrete subclasses.

function f(){eval("var x; x = (delete x, 0);")}

Lexical Environment Operations

The following abstract operations are used in this specification to operate upon lexical environments:

CreateRealm ( )

The abstract operation CreateRealm with no arguments performs the following steps:

CreateIntrinsics ( _realmRec_ )

The abstract operation CreateIntrinsics with argument _realmRec_ performs the following steps:

SetRealmGlobalObject ( _realmRec_, _globalObj_, _thisValue_ )

The abstract operation SetRealmGlobalObject with arguments _realmRec_, _globalObj_, and _thisValue_ performs the following steps:

SetDefaultGlobalBindings ( _realmRec_ )

The abstract operation SetDefaultGlobalBindings with argument _realmRec_ performs the following steps:

GetActiveScriptOrModule ( )

The GetActiveScriptOrModule abstract operation is used to determine the running script or module, based on the running execution context. GetActiveScriptOrModule performs the following steps:

ResolveBinding ( _name_ [ , _env_ ] )

The ResolveBinding abstract operation is used to determine the binding of _name_ passed as a String value. The optional argument _env_ can be used to explicitly provide the Lexical Environment that is to be searched for the binding. During execution of ECMAScript code, ResolveBinding is performed using the following algorithm:

GetThisEnvironment ( )

The abstract operation GetThisEnvironment finds the Environment Record that currently supplies the binding of the keyword `this`. GetThisEnvironment performs the following steps:

ResolveThisBinding ( )

The abstract operation ResolveThisBinding determines the binding of the keyword `this` using the LexicalEnvironment of the running execution context. ResolveThisBinding performs the following steps:

GetNewTarget ( )

The abstract operation GetNewTarget determines the NewTarget value using the LexicalEnvironment of the running execution context. GetNewTarget performs the following steps:

GetGlobalObject ( )

The abstract operation GetGlobalObject returns the global object used by the currently running execution context. GetGlobalObject performs the following steps:

EnqueueJob ( _queueName_, _job_, _arguments_ )

The EnqueueJob abstract operation requires three arguments: _queueName_, _job_, and _arguments_. It performs the following steps:

AgentSignifier ( )

The abstract operation AgentSignifier takes no arguments. It performs the following steps:

AgentCanSuspend ( )

The abstract operation AgentCanSuspend takes no arguments. It performs the following steps:

[[GetPrototypeOf]] ( )

When the [[GetPrototypeOf]] internal method of _O_ is called, the following steps are taken:

[[SetPrototypeOf]] ( _V_ )

When the [[SetPrototypeOf]] internal method of _O_ is called with argument _V_, the following steps are taken:

[[IsExtensible]] ( )

When the [[IsExtensible]] internal method of _O_ is called, the following steps are taken:

[[PreventExtensions]] ( )

When the [[PreventExtensions]] internal method of _O_ is called, the following steps are taken:

[[GetOwnProperty]] ( _P_ )

When the [[GetOwnProperty]] internal method of _O_ is called with property key _P_, the following steps are taken:

[[DefineOwnProperty]] ( _P_, _Desc_ )

When the [[DefineOwnProperty]] internal method of _O_ is called with property key _P_ and Property Descriptor _Desc_, the following steps are taken:

[[HasProperty]] ( _P_ )

When the [[HasProperty]] internal method of _O_ is called with property key _P_, the following steps are taken:

[[Get]] ( _P_, _Receiver_ )

When the [[Get]] internal method of _O_ is called with property key _P_ and ECMAScript language value _Receiver_, the following steps are taken:

[[Set]] ( _P_, _V_, _Receiver_ )

When the [[Set]] internal method of _O_ is called with property key _P_, value _V_, and ECMAScript language value _Receiver_, the following steps are taken:

[[Delete]] ( _P_ )

When the [[Delete]] internal method of _O_ is called with property key _P_, the following steps are taken:

[[OwnPropertyKeys]] ( )

When the [[OwnPropertyKeys]] internal method of _O_ is called, the following steps are taken:

ObjectCreate ( _proto_ [ , _internalSlotsList_ ] )

The abstract operation ObjectCreate with argument _proto_ (an object or null) is used to specify the runtime creation of new ordinary objects. The optional argument _internalSlotsList_ is a List of the names of additional internal slots that must be defined as part of the object. If the list is not provided, a new empty List is used. This abstract operation performs the following steps:

OrdinaryCreateFromConstructor ( _constructor_, _intrinsicDefaultProto_ [ , _internalSlotsList_ ] )

The abstract operation OrdinaryCreateFromConstructor creates an ordinary object whose [[Prototype]] value is retrieved from a constructor's `prototype` property, if it exists. Otherwise the intrinsic named by _intrinsicDefaultProto_ is used for [[Prototype]]. The optional _internalSlotsList_ is a List of the names of additional internal slots that must be defined as part of the object. If the list is not provided, a new empty List is used. This abstract operation performs the following steps:

GetPrototypeFromConstructor ( _constructor_, _intrinsicDefaultProto_ )

The abstract operation GetPrototypeFromConstructor determines the [[Prototype]] value that should be used to create an object corresponding to a specific constructor. The value is retrieved from the constructor's `prototype` property, if it exists. Otherwise the intrinsic named by _intrinsicDefaultProto_ is used for [[Prototype]]. This abstract operation performs the following steps:

[[Call]] ( _thisArgument_, _argumentsList_ )

The [[Call]] internal method for an ECMAScript function object _F_ is called with parameters _thisArgument_ and _argumentsList_, a List of ECMAScript language values. The following steps are taken:

[[Construct]] ( _argumentsList_, _newTarget_ )

The [[Construct]] internal method for an ECMAScript function object _F_ is called with parameters _argumentsList_ and _newTarget_. _argumentsList_ is a possibly empty List of ECMAScript language values. The following steps are taken:

FunctionAllocate ( _functionPrototype_, _strict_, _functionKind_ )

The abstract operation FunctionAllocate requires the three arguments _functionPrototype_, _strict_ and _functionKind_. FunctionAllocate performs the following steps:

FunctionInitialize ( _F_, _kind_, _ParameterList_, _Body_, _Scope_ )

The abstract operation FunctionInitialize requires the arguments: a function object _F_, _kind_ which is one of (Normal, Method, Arrow), a parameter list Parse Node specified by _ParameterList_, a body Parse Node specified by _Body_, a Lexical Environment specified by _Scope_. FunctionInitialize performs the following steps:

FunctionCreate ( _kind_, _ParameterList_, _Body_, _Scope_, _Strict_ [ , _prototype_ ] )

The abstract operation FunctionCreate requires the arguments: _kind_ which is one of (Normal, Method, Arrow), a parameter list Parse Node specified by _ParameterList_, a body Parse Node specified by _Body_, a Lexical Environment specified by _Scope_, a Boolean flag _Strict_, and optionally, an object _prototype_. FunctionCreate performs the following steps:

GeneratorFunctionCreate ( _kind_, _ParameterList_, _Body_, _Scope_, _Strict_ )

The abstract operation GeneratorFunctionCreate requires the arguments: _kind_ which is one of (Normal, Method), a parameter list Parse Node specified by _ParameterList_, a body Parse Node specified by _Body_, a Lexical Environment specified by _Scope_, and a Boolean flag _Strict_. GeneratorFunctionCreate performs the following steps:

AsyncGeneratorFunctionCreate ( _kind_, _ParameterList_, _Body_, _Scope_, _Strict_ )

The abstract operation AsyncGeneratorFunctionCreate requires the arguments: _kind_ which is one of (~Normal~, ~Method~), a parameter list Parse Node specified by _ParameterList_, a body Parse Node specified by _Body_, a Lexical Environment specified by _Scope_, and a Boolean flag _Strict_. AsyncGeneratorFunctionCreate performs the following steps:

AsyncFunctionCreate ( _kind_, _parameters_, _body_, _Scope_, _Strict_ )

The abstract operation AsyncFunctionCreate requires the arguments: _kind_ which is one of (~Normal~, ~Method~, ~Arrow~), a parameter list Parse Node specified by _parameters_, a body Parse Node specified by _body_, a Lexical Environment specified by _Scope_, and a Boolean flag _Strict_. AsyncFunctionCreate performs the following steps:

AddRestrictedFunctionProperties ( _F_, _realm_ )

The abstract operation AddRestrictedFunctionProperties is called with a function object _F_ and Realm Record _realm_ as its argument. It performs the following steps:

MakeConstructor ( _F_ [ , _writablePrototype_ [ , _prototype_ ] ] )

The abstract operation MakeConstructor requires a Function argument _F_ and optionally, a Boolean _writablePrototype_ and an object _prototype_. If _prototype_ is provided it is assumed to already contain, if needed, a `"constructor"` property whose value is _F_. This operation converts _F_ into a constructor by performing the following steps:

MakeClassConstructor ( _F_ )

The abstract operation MakeClassConstructor with argument _F_ performs the following steps:

MakeMethod ( _F_, _homeObject_ )

The abstract operation MakeMethod with arguments _F_ and _homeObject_ configures _F_ as a method by performing the following steps:

SetFunctionName ( _F_, _name_ [ , _prefix_ ] )

The abstract operation SetFunctionName requires a Function argument _F_, a String or Symbol argument _name_ and optionally a String argument _prefix_. This operation adds a `name` property to _F_ by performing the following steps:

SetFunctionLength ( _F_, _length_ )

The abstract operation SetFunctionLength requires a Function argument _F_ and a Number argument _length_. This operation adds a `length` property to _F_ by performing the following steps:

FunctionDeclarationInstantiation ( _func_, _argumentsList_ )

FunctionDeclarationInstantiation is performed as follows using arguments _func_ and _argumentsList_. _func_ is the function object for which the execution context is being established.

[[Call]] ( _thisArgument_, _argumentsList_ )

The [[Call]] internal method for a built-in function object _F_ is called with parameters _thisArgument_ and _argumentsList_, a List of ECMAScript language values. The following steps are taken:

[[Construct]] ( _argumentsList_, _newTarget_ )

The [[Construct]] internal method for built-in function object _F_ is called with parameters _argumentsList_ and _newTarget_. The steps performed are the same as [[Call]] (see ) except that step 10 is replaced by:

CreateBuiltinFunction ( _steps_, _internalSlotsList_ [ , _realm_ [ , _prototype_ ] ] )

The abstract operation CreateBuiltinFunction takes arguments _steps_, _internalSlotsList_, _realm_, and _prototype_. The argument _internalSlotsList_ is a List of the names of additional internal slots that must be defined as part of the object. CreateBuiltinFunction returns a built-in function object created by the following steps:

Each built-in function defined in this specification is created by calling the CreateBuiltinFunction abstract operation.

Bound Function Exotic Objects

A bound function is an exotic object that wraps another function object. A bound function is callable (it has a [[Call]] internal method and may have a [[Construct]] internal method). Calling a bound function generally results in a call of its wrapped function.

Bound function objects do not have the internal slots of ECMAScript function objects defined in . Instead they have the internal slots defined in .

Bound function objects provide all of the essential internal methods as specified in . However, they use the following definitions for the essential internal methods of function objects.

Array Exotic Objects

An Array object is an exotic object that gives special treatment to array index property keys (see ). A property whose property name is an array index is also called an element. Every Array object has a `length` property whose value is always a nonnegative integer less than 2³². The value of the `length` property is numerically greater than the name of every own property whose name is an array index; whenever an own property of an Array object is created or changed, other properties are adjusted as necessary to maintain this invariant. Specifically, whenever an own property is added whose name is an array index, the value of the `length` property is changed, if necessary, to be one more than the numeric value of that array index; and whenever the value of the `length` property is changed, every own property whose name is an array index whose value is not smaller than the new length is deleted. This constraint applies only to own properties of an Array object and is unaffected by `length` or array index properties that may be inherited from its prototypes.

Array exotic objects always have a non-configurable property named `"length"`.

Array exotic objects provide an alternative definition for the [[DefineOwnProperty]] internal method. Except for that internal method, Array exotic objects provide all of the other essential internal methods as specified in .

String Exotic Objects

A String object is an exotic object that encapsulates a String value and exposes virtual integer-indexed data properties corresponding to the individual code unit elements of the String value. String exotic objects always have a data property named `"length"` whose value is the number of code unit elements in the encapsulated String value. Both the code unit data properties and the `"length"` property are non-writable and non-configurable.

String exotic objects have the same internal slots as ordinary objects. They also have a [[StringData]] internal slot.

String exotic objects provide alternative definitions for the following internal methods. All of the other String exotic object essential internal methods that are not defined below are as specified in .

Arguments Exotic Objects

Most ECMAScript functions make an arguments object available to their code. Depending upon the characteristics of the function definition, its arguments object is either an ordinary object or an arguments exotic object. An arguments exotic object is an exotic object whose array index properties map to the formal parameters bindings of an invocation of its associated ECMAScript function.

Arguments exotic objects have the same internal slots as ordinary objects. They also have a [[ParameterMap]] internal slot. Ordinary arguments objects also have a [[ParameterMap]] internal slot whose value is always undefined. For ordinary argument objects the [[ParameterMap]] internal slot is only used by `Object.prototype.toString` () to identify them as such.

Arguments exotic objects provide alternative definitions for the following internal methods. All of the other arguments exotic object essential internal methods that are not defined below are as specified in

Integer-Indexed Exotic Objects

An Integer-Indexed exotic object is an exotic object that performs special handling of integer index property keys.

Integer-Indexed exotic objects have the same internal slots as ordinary objects and additionally [[ViewedArrayBuffer]], [[ArrayLength]], [[ByteOffset]], and [[TypedArrayName]] internal slots.

Integer-Indexed exotic objects provide alternative definitions for the following internal methods. All of the other Integer-Indexed exotic object essential internal methods that are not defined below are as specified in .

Module Namespace Exotic Objects

A module namespace object is an exotic object that exposes the bindings exported from an ECMAScript |Module| (See ). There is a one-to-one correspondence between the String-keyed own properties of a module namespace exotic object and the binding names exported by the |Module|. The exported bindings include any bindings that are indirectly exported using `export *` export items. Each String-valued own property key is the StringValue of the corresponding exported binding name. These are the only String-keyed properties of a module namespace exotic object. Each such property has the attributes { [[Writable]]: *true*, [[Enumerable]]: *true*, [[Configurable]]: *false* }. Module namespace objects are not extensible.

Module namespace objects have the internal slots defined in .

Module namespace exotic objects provide alternative definitions for all of the internal methods except [[GetPrototypeOf]], which behaves as defined in .

Immutable Prototype Exotic Objects

An immutable prototype exotic object is an exotic object that has a [[Prototype]] internal slot that will not change once it is initialized.

Immutable prototype exotic objects have the same internal slots as ordinary objects. They are exotic only in the following internal methods. All other internal methods of immutable prototype exotic objects that are not explicitly defined below are instead defined as in ordinary objects.

[[GetPrototypeOf]] ( )

When the [[GetPrototypeOf]] internal method of a Proxy exotic object _O_ is called, the following steps are taken:

[[SetPrototypeOf]] ( _V_ )

When the [[SetPrototypeOf]] internal method of a Proxy exotic object _O_ is called with argument _V_, the following steps are taken:

[[IsExtensible]] ( )

When the [[IsExtensible]] internal method of a Proxy exotic object _O_ is called, the following steps are taken:

[[PreventExtensions]] ( )

When the [[PreventExtensions]] internal method of a Proxy exotic object _O_ is called, the following steps are taken:

[[GetOwnProperty]] ( _P_ )

When the [[GetOwnProperty]] internal method of a Proxy exotic object _O_ is called with property key _P_, the following steps are taken:

[[DefineOwnProperty]] ( _P_, _Desc_ )

When the [[DefineOwnProperty]] internal method of a Proxy exotic object _O_ is called with property key _P_ and Property Descriptor _Desc_, the following steps are taken:

[[HasProperty]] ( _P_ )

When the [[HasProperty]] internal method of a Proxy exotic object _O_ is called with property key _P_, the following steps are taken:

[[Get]] ( _P_, _Receiver_ )

When the [[Get]] internal method of a Proxy exotic object _O_ is called with property key _P_ and ECMAScript language value _Receiver_, the following steps are taken:

[[Set]] ( _P_, _V_, _Receiver_ )

When the [[Set]] internal method of a Proxy exotic object _O_ is called with property key _P_, value _V_, and ECMAScript language value _Receiver_, the following steps are taken:

[[Delete]] ( _P_ )

When the [[Delete]] internal method of a Proxy exotic object _O_ is called with property key _P_, the following steps are taken:

[[OwnPropertyKeys]] ( )

When the [[OwnPropertyKeys]] internal method of a Proxy exotic object _O_ is called, the following steps are taken:

[[Call]] ( _thisArgument_, _argumentsList_ )

The [[Call]] internal method of a Proxy exotic object _O_ is called with parameters _thisArgument_ and _argumentsList_, a List of ECMAScript language values. The following steps are taken:

[[Construct]] ( _argumentsList_, _newTarget_ )

The [[Construct]] internal method of a Proxy exotic object _O_ is called with parameters _argumentsList_ which is a possibly empty List of ECMAScript language values and _newTarget_. The following steps are taken:

ProxyCreate ( _target_, _handler_ )

The abstract operation ProxyCreate with arguments _target_ and _handler_ is used to specify the creation of new Proxy exotic objects. It performs the following steps:

Static Semantics: UTF16Encoding ( _cp_ )

The UTF16Encoding of a numeric code point value, _cp_, is determined as follows:

Static Semantics: UTF16Decode ( _lead_, _trail_ )

Two code units, _lead_ and _trail_, that form a UTF-16 are converted to a code point by performing the following steps:

Strict Mode Code

An ECMAScript |Script| syntactic unit may be processed using either unrestricted or strict mode syntax and semantics. Code is interpreted as strict mode code in the following situations:

• Global code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive.
• Module code is always strict mode code.
• All parts of a |ClassDeclaration| or a |ClassExpression| are strict mode code.
• Eval code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive or if the call to `eval` is a direct eval that is contained in strict mode code.
• Function code is strict mode code if the associated |FunctionDeclaration|, |FunctionExpression|, |GeneratorDeclaration|, |GeneratorExpression|, |AsyncFunctionDeclaration|, |AsyncFunctionExpression|, |AsyncGeneratorDeclaration|, |AsyncGeneratorExpression|, |MethodDefinition|, |ArrowFunction|, or |AsyncArrowFunction| is contained in strict mode code or if the code that produces the value of the function's [[ECMAScriptCode]] internal slot begins with a Directive Prologue that contains a Use Strict Directive.
• Function code that is supplied as the arguments to the built-in `Function`, `Generator`, `AsyncFunction`, and `AsyncGenerator` constructors is strict mode code if the last argument is a String that when processed is a |FunctionBody| that begins with a Directive Prologue that contains a Use Strict Directive.

ECMAScript code that is not strict mode code is called non-strict code.

Non-ECMAScript Functions

An ECMAScript implementation may support the evaluation of function exotic objects whose evaluative behaviour is expressed in some implementation-defined form of executable code other than via ECMAScript code. Whether a function object is an ECMAScript code function or a non-ECMAScript function is not semantically observable from the perspective of an ECMAScript code function that calls or is called by such a non-ECMAScript function.

Identifier Names

Reserved Words

A reserved word is an |IdentifierName| that cannot be used as an |Identifier|.

Syntax

Null Literals

Syntax

Boolean Literals

Syntax

Numeric Literals

Syntax

The |SourceCharacter| immediately following a |NumericLiteral| must not be an |IdentifierStart| or |DecimalDigit|.

A conforming implementation, when processing strict mode code, must not extend, as described in , the syntax of |NumericLiteral| to include , nor extend the syntax of |DecimalIntegerLiteral| to include .

String Literals

Syntax

A conforming implementation, when processing strict mode code, must not extend the syntax of |EscapeSequence| to include as described in .

The definition of the nonterminal |HexDigit| is given in . |SourceCharacter| is defined in .

Regular Expression Literals

The productions below describe the syntax for a regular expression literal and are used by the input element scanner to find the end of the regular expression literal. The source text comprising the |RegularExpressionBody| and the |RegularExpressionFlags| are subsequently parsed again using the more stringent ECMAScript Regular Expression grammar ().

An implementation may extend the ECMAScript Regular Expression grammar defined in , but it must not extend the |RegularExpressionBody| and |RegularExpressionFlags| productions defined below or the productions used by these productions.

Syntax

Template Literal Lexical Components

Syntax

A conforming implementation must not use the extended definition of |EscapeSequence| described in when parsing a |TemplateCharacter|.

Rules of Automatic Semicolon Insertion

In the following rules, “token” means the actual recognized lexical token determined using the current lexical goal symbol as described in clause .

There are three basic rules of semicolon insertion:

1. When, as the source text is parsed from left to right, a token (called the offending token) is encountered that is not allowed by any production of the grammar, then a semicolon is automatically inserted before the offending token if one or more of the following conditions is true:

   • The offending token is separated from the previous token by at least one |LineTerminator|.
   • The offending token is `}`.
   • The previous token is `)` and the inserted semicolon would then be parsed as the terminating semicolon of a do-while statement ().
2. When, as the source text is parsed from left to right, the end of the input stream of tokens is encountered and the parser is unable to parse the input token stream as a single instance of the goal nonterminal, then a semicolon is automatically inserted at the end of the input stream.
3. When, as the source text is parsed from left to right, a token is encountered that is allowed by some production of the grammar, but the production is a restricted production and the token would be the first token for a terminal or nonterminal immediately following the annotation “[no |LineTerminator| here]” within the restricted production (and therefore such a token is called a restricted token), and the restricted token is separated from the previous token by at least one |LineTerminator|, then a semicolon is automatically inserted before the restricted token.

However, there is an additional overriding condition on the preceding rules: a semicolon is never inserted automatically if the semicolon would then be parsed as an empty statement or if that semicolon would become one of the two semicolons in the header of a `for` statement (see ).

Examples of Automatic Semicolon Insertion

The source

{ 1 2 } 3

is not a valid sentence in the ECMAScript grammar, even with the automatic semicolon insertion rules. In contrast, the source

        { 1
        2 } 3
      

is also not a valid ECMAScript sentence, but is transformed by automatic semicolon insertion into the following:

        { 1
        ;2 ;} 3;
      

which is a valid ECMAScript sentence.

The source

        for (a; b
        )
      

is not a valid ECMAScript sentence and is not altered by automatic semicolon insertion because the semicolon is needed for the header of a `for` statement. Automatic semicolon insertion never inserts one of the two semicolons in the header of a `for` statement.

The source

        return
        a + b
      

is transformed by automatic semicolon insertion into the following:

        return;
        a + b;
      

The source

        a = b
        ++c
      

is transformed by automatic semicolon insertion into the following:

        a = b;
        ++c;
      

The source

        if (a > b)
        else c = d
      

is not a valid ECMAScript sentence and is not altered by automatic semicolon insertion before the `else` token, even though no production of the grammar applies at that point, because an automatically inserted semicolon would then be parsed as an empty statement.

The source

        a = b + c
        (d + e).print()
      

is not transformed by automatic semicolon insertion, because the parenthesized expression that begins the second line can be interpreted as an argument list for a function call:

a = b + c(d + e).print()

In the circumstance that an assignment statement must begin with a left parenthesis, it is a good idea for the programmer to provide an explicit semicolon at the end of the preceding statement rather than to rely on automatic semicolon insertion.

Static Semantics: Early Errors

• It is a Syntax Error if the code matched by this production is contained in strict mode code and the StringValue of |Identifier| is `"arguments"` or `"eval"`.

• It is a Syntax Error if the code matched by this production is contained in strict mode code.

• It is a Syntax Error if the goal symbol of the syntactic grammar is |Module|.

• It is a Syntax Error if this production has a _[Yield] parameter.

• It is a Syntax Error if this production has an _[Await] parameter.

• It is a Syntax Error if this production has a _[Yield] parameter and StringValue of |Identifier| is `"yield"`.
• It is a Syntax Error if this production has an _[Await] parameter and StringValue of |Identifier| is `"await"`.

• It is a Syntax Error if this phrase is contained in strict mode code and the StringValue of |IdentifierName| is: `"implements"`, `"interface"`, `"let"`, `"package"`, `"private"`, `"protected"`, `"public"`, `"static"`, or `"yield"`.
• It is a Syntax Error if the goal symbol of the syntactic grammar is |Module| and the StringValue of |IdentifierName| is `"await"`.
• It is a Syntax Error if StringValue of |IdentifierName| is the same String value as the StringValue of any |ReservedWord| except for `yield` or `await`.

Static Semantics: BoundNames

Static Semantics: IsValidSimpleAssignmentTarget

Static Semantics: StringValue

Runtime Semantics: BindingInitialization

With parameters _value_ and _environment_.

Runtime Semantics: Evaluation

Semantics

The `this` Keyword

Identifier Reference

See for |IdentifierReference|.

Literals

Syntax

Array Initializer

Array elements may be elided at the beginning, middle or end of the element list. Whenever a comma in the element list is not preceded by an |AssignmentExpression| (i.e., a comma at the beginning or after another comma), the missing array element contributes to the length of the Array and increases the index of subsequent elements. Elided array elements are not defined. If an element is elided at the end of an array, that element does not contribute to the length of the Array.

Syntax

Object Initializer

Syntax

Function Defining Expressions

See for PrimaryExpression : FunctionExpression.

See for PrimaryExpression : GeneratorExpression.

See for PrimaryExpression : ClassExpression.

See for PrimaryExpression : AsyncFunctionExpression.

See for PrimaryExpression : AsyncGeneratorExpression.

Regular Expression Literals

Syntax

See .

Template Literals

Syntax

The Grouping Operator

Static Semantics

Property Accessors

The `new` Operator

Function Calls

The `super` Keyword

Argument Lists

Tagged Templates

Meta Properties

Static Semantics: Early Errors

• It is an early Reference Error if IsValidSimpleAssignmentTarget of |LeftHandSideExpression| is *false*.

• It is an early Reference Error if IsValidSimpleAssignmentTarget of |UnaryExpression| is *false*.

Static Semantics: IsFunctionDefinition

Static Semantics: IsValidSimpleAssignmentTarget

Postfix Increment Operator

Postfix Decrement Operator

Prefix Increment Operator

Prefix Decrement Operator

Static Semantics: IsFunctionDefinition

Static Semantics: IsValidSimpleAssignmentTarget

The `delete` Operator

The `void` Operator

The `typeof` Operator

Unary `+` Operator

Unary `-` Operator

Bitwise NOT Operator ( `~` )

Logical NOT Operator ( `!` )

Static Semantics: IsFunctionDefinition

Static Semantics: IsValidSimpleAssignmentTarget

Runtime Semantics: Evaluation

Applying the `**` Operator

Returns an implementation-dependent approximation of the result of raising _base_ to the power _exponent_.

• If _exponent_ is *NaN*, the result is *NaN*.
• If _exponent_ is *+0*, the result is 1, even if _base_ is *NaN*.
• If _exponent_ is *-0*, the result is 1, even if _base_ is *NaN*.
• If _base_ is *NaN* and _exponent_ is nonzero, the result is *NaN*.
• If abs(_base_) > 1 and _exponent_ is *+∞*, the result is *+∞*.
• If abs(_base_) > 1 and _exponent_ is *-∞*, the result is *+0*.
• If abs(_base_) is 1 and _exponent_ is *+∞*, the result is *NaN*.
• If abs(_base_) is 1 and _exponent_ is *-∞*, the result is *NaN*.
• If abs(_base_) < 1 and _exponent_ is *+∞*, the result is *+0*.
• If abs(_base_) < 1 and _exponent_ is *-∞*, the result is *+∞*.
• If _base_ is *+∞* and _exponent_ > 0, the result is *+∞*.
• If _base_ is *+∞* and _exponent_ < 0, the result is *+0*.
• If _base_ is *-∞* and _exponent_ > 0 and _exponent_ is an odd integer, the result is *-∞*.
• If _base_ is *-∞* and _exponent_ > 0 and _exponent_ is not an odd integer, the result is *+∞*.
• If _base_ is *-∞* and _exponent_ < 0 and _exponent_ is an odd integer, the result is *-0*.
• If _base_ is *-∞* and _exponent_ < 0 and _exponent_ is not an odd integer, the result is *+0*.
• If _base_ is *+0* and _exponent_ > 0, the result is *+0*.
• If _base_ is *+0* and _exponent_ < 0, the result is *+∞*.
• If _base_ is *-0* and _exponent_ > 0 and _exponent_ is an odd integer, the result is *-0*.
• If _base_ is *-0* and _exponent_ > 0 and _exponent_ is not an odd integer, the result is *+0*.
• If _base_ is *-0* and _exponent_ < 0 and _exponent_ is an odd integer, the result is *-∞*.
• If _base_ is *-0* and _exponent_ < 0 and _exponent_ is not an odd integer, the result is *+∞*.
• If _base_ < 0 and _base_ is finite and _exponent_ is finite and _exponent_ is not an integer, the result is *NaN*.

Static Semantics: IsFunctionDefinition

Static Semantics: IsValidSimpleAssignmentTarget

Runtime Semantics: Evaluation

Static Semantics: IsFunctionDefinition

Static Semantics: IsValidSimpleAssignmentTarget

The Addition Operator ( `+` )

The Subtraction Operator ( `-` )

Applying the Additive Operators to Numbers

The `+` operator performs addition when applied to two operands of numeric type, producing the sum of the operands. The `-` operator performs subtraction, producing the difference of two numeric operands.

Addition is a commutative operation, but not always associative.

The result of an addition is determined using the rules of IEEE 754-2008 binary double-precision arithmetic:

• If either operand is *NaN*, the result is *NaN*.
• The sum of two infinities of opposite sign is *NaN*.
• The sum of two infinities of the same sign is the infinity of that sign.
• The sum of an infinity and a finite value is equal to the infinite operand.
• The sum of two negative zeroes is *-0*. The sum of two positive zeroes, or of two zeroes of opposite sign, is *+0*.
• The sum of a zero and a nonzero finite value is equal to the nonzero operand.
• The sum of two nonzero finite values of the same magnitude and opposite sign is *+0*.
• In the remaining cases, where neither an infinity, nor a zero, nor *NaN* is involved, and the operands have the same sign or have different magnitudes, the sum is computed and rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode. If the magnitude is too large to represent, the operation overflows and the result is then an infinity of appropriate sign. The ECMAScript language requires support of gradual underflow as defined by IEEE 754-2008.

Static Semantics: IsFunctionDefinition

Static Semantics: IsValidSimpleAssignmentTarget

The Left Shift Operator ( `<<` )

The Signed Right Shift Operator ( `>>` )

The Unsigned Right Shift Operator ( `>>>` )

Static Semantics: IsFunctionDefinition

Static Semantics: IsValidSimpleAssignmentTarget

Runtime Semantics: Evaluation

Runtime Semantics: InstanceofOperator ( _V_, _target_ )

The abstract operation InstanceofOperator(_V_, _target_) implements the generic algorithm for determining if ECMAScript value _V_ is an instance of object _target_ either by consulting _target_'s @@hasinstance method or, if absent, determining whether the value of _target_'s `prototype` property is present in _V_'s prototype chain. This abstract operation performs the following steps:

Static Semantics: IsFunctionDefinition

Static Semantics: IsValidSimpleAssignmentTarget

Runtime Semantics: Evaluation

Static Semantics: IsFunctionDefinition

Static Semantics: IsValidSimpleAssignmentTarget

Runtime Semantics: Evaluation

The production A : A @ B, where @ is one of the bitwise operators in the productions above, is evaluated as follows:

Static Semantics: IsFunctionDefinition

Static Semantics: IsValidSimpleAssignmentTarget

Runtime Semantics: Evaluation

Static Semantics: IsFunctionDefinition

Static Semantics: IsValidSimpleAssignmentTarget

Runtime Semantics: Evaluation

Static Semantics: Early Errors

• It is a Syntax Error if |LeftHandSideExpression| is either an |ObjectLiteral| or an |ArrayLiteral| and |LeftHandSideExpression| is not covering an |AssignmentPattern|.
• It is an early Reference Error if |LeftHandSideExpression| is neither an |ObjectLiteral| nor an |ArrayLiteral| and IsValidSimpleAssignmentTarget of |LeftHandSideExpression| is *false*.

• It is an early Reference Error if IsValidSimpleAssignmentTarget of |LeftHandSideExpression| is *false*.

Static Semantics: IsFunctionDefinition

Static Semantics: IsValidSimpleAssignmentTarget

Runtime Semantics: Evaluation

Destructuring Assignment

Supplemental Syntax

In certain circumstances when processing an instance of the production AssignmentExpression : LeftHandSideExpression `=` AssignmentExpression the following grammar is used to refine the interpretation of |LeftHandSideExpression|.

Static Semantics: IsFunctionDefinition

Static Semantics: IsValidSimpleAssignmentTarget

Runtime Semantics: Evaluation

Static Semantics: ContainsDuplicateLabels

With parameter _labelSet_.

Static Semantics: ContainsUndefinedBreakTarget

With parameter _labelSet_.

Static Semantics: ContainsUndefinedContinueTarget

With parameters _iterationSet_ and _labelSet_.

Static Semantics: DeclarationPart

Static Semantics: VarDeclaredNames

Static Semantics: VarScopedDeclarations

Runtime Semantics: LabelledEvaluation

With parameter _labelSet_.

Runtime Semantics: Evaluation

Static Semantics: Early Errors

• It is a Syntax Error if the LexicallyDeclaredNames of |StatementList| contains any duplicate entries.
• It is a Syntax Error if any element of the LexicallyDeclaredNames of |StatementList| also occurs in the VarDeclaredNames of |StatementList|.

Static Semantics: ContainsDuplicateLabels

With parameter _labelSet_.

Static Semantics: ContainsUndefinedBreakTarget

With parameter _labelSet_.

Static Semantics: ContainsUndefinedContinueTarget

With parameters _iterationSet_ and _labelSet_.

Static Semantics: LexicallyDeclaredNames

Static Semantics: LexicallyScopedDeclarations

Static Semantics: TopLevelLexicallyDeclaredNames

Static Semantics: TopLevelLexicallyScopedDeclarations

Static Semantics: TopLevelVarDeclaredNames

Static Semantics: TopLevelVarScopedDeclarations

Static Semantics: VarDeclaredNames

Static Semantics: VarScopedDeclarations

Runtime Semantics: Evaluation

          eval("1;;;;;")
          eval("1;{}")
          eval("1;var a;")
        

Runtime Semantics: BlockDeclarationInstantiation ( _code_, _env_ )

BlockDeclarationInstantiation is performed as follows using arguments _code_ and _env_. _code_ is the Parse Node corresponding to the body of the block. _env_ is the Lexical Environment in which bindings are to be created.

Let and Const Declarations

Syntax

Variable Statement

Syntax

Destructuring Binding Patterns

Syntax

Runtime Semantics: Evaluation

Runtime Semantics: Evaluation

Static Semantics: Early Errors

• It is a Syntax Error if IsLabelledFunction(|Statement|) is *true*.

Static Semantics: ContainsDuplicateLabels

With parameter _labelSet_.

Static Semantics: ContainsUndefinedBreakTarget

With parameter _labelSet_.

Static Semantics: ContainsUndefinedContinueTarget

With parameters _iterationSet_ and _labelSet_.

Static Semantics: VarDeclaredNames

Static Semantics: VarScopedDeclarations

Runtime Semantics: Evaluation

Semantics

The `do`-`while` Statement

The `while` Statement

The `for` Statement

The `for`-`in`, `for`-`of`, and `for`-`await`-`of` Statements

            function* EnumerateObjectProperties(obj) {
              const visited = new Set();
              for (const key of Reflect.ownKeys(obj)) {
                if (typeof key === "symbol") continue;
                const desc = Reflect.getOwnPropertyDescriptor(obj, key);
                if (desc) {
                  visited.add(key);
                  if (desc.enumerable) yield key;
                }
              }
              const proto = Reflect.getPrototypeOf(obj);
              if (proto === null) return;
              for (const protoKey of EnumerateObjectProperties(proto)) {
                if (!visited.has(protoKey)) yield protoKey;
              }
            }
          

Static Semantics: Early Errors

• It is a Syntax Error if this |ContinueStatement| is not nested, directly or indirectly (but not crossing function boundaries), within an |IterationStatement|.

Static Semantics: ContainsUndefinedContinueTarget

With parameters _iterationSet_ and _labelSet_.

Runtime Semantics: Evaluation

Static Semantics: Early Errors

• It is a Syntax Error if this |BreakStatement| is not nested, directly or indirectly (but not crossing function boundaries), within an |IterationStatement| or a |SwitchStatement|.

Static Semantics: ContainsUndefinedBreakTarget

With parameter _labelSet_.

Runtime Semantics: Evaluation

Runtime Semantics: Evaluation

Static Semantics: Early Errors

• It is a Syntax Error if the code that matches this production is contained in strict mode code.
• It is a Syntax Error if IsLabelledFunction(|Statement|) is *true*.

Static Semantics: ContainsDuplicateLabels

With parameter _labelSet_.

Static Semantics: ContainsUndefinedBreakTarget

With parameter _labelSet_.

Static Semantics: ContainsUndefinedContinueTarget

With parameters _iterationSet_ and _labelSet_.

Static Semantics: VarDeclaredNames

Static Semantics: VarScopedDeclarations

Runtime Semantics: Evaluation

Static Semantics: Early Errors

• It is a Syntax Error if the LexicallyDeclaredNames of |CaseBlock| contains any duplicate entries.
• It is a Syntax Error if any element of the LexicallyDeclaredNames of |CaseBlock| also occurs in the VarDeclaredNames of |CaseBlock|.

Static Semantics: ContainsDuplicateLabels

With parameter _labelSet_.

Static Semantics: ContainsUndefinedBreakTarget

With parameter _labelSet_.

Static Semantics: ContainsUndefinedContinueTarget

With parameters _iterationSet_ and _labelSet_.

Static Semantics: LexicallyDeclaredNames

Static Semantics: LexicallyScopedDeclarations

Static Semantics: VarDeclaredNames

Static Semantics: VarScopedDeclarations

Runtime Semantics: CaseBlockEvaluation

With parameter _input_.

Runtime Semantics: CaseClauseIsSelected ( _C_, _input_ )

The abstract operation CaseClauseIsSelected, given |CaseClause| _C_ and value _input_, determines whether _C_ matches _input_.

Runtime Semantics: Evaluation

Static Semantics: Early Errors

• It is a Syntax Error if any source text matches this rule.

Static Semantics: ContainsDuplicateLabels

With parameter _labelSet_.

Static Semantics: ContainsUndefinedBreakTarget

With parameter _labelSet_.

Static Semantics: ContainsUndefinedContinueTarget

With parameters _iterationSet_ and _labelSet_.

Static Semantics: IsLabelledFunction ( _stmt_ )

The abstract operation IsLabelledFunction with argument _stmt_ performs the following steps:

Static Semantics: LexicallyDeclaredNames

Static Semantics: LexicallyScopedDeclarations

Static Semantics: TopLevelLexicallyDeclaredNames

Static Semantics: TopLevelLexicallyScopedDeclarations

Static Semantics: TopLevelVarDeclaredNames

Static Semantics: TopLevelVarScopedDeclarations

Static Semantics: VarDeclaredNames

Static Semantics: VarScopedDeclarations

Runtime Semantics: LabelledEvaluation

With parameter _labelSet_.

Runtime Semantics: Evaluation

Runtime Semantics: Evaluation

Static Semantics: Early Errors

• It is a Syntax Error if BoundNames of |CatchParameter| contains any duplicate elements.
• It is a Syntax Error if any element of the BoundNames of |CatchParameter| also occurs in the LexicallyDeclaredNames of |Block|.
• It is a Syntax Error if any element of the BoundNames of |CatchParameter| also occurs in the VarDeclaredNames of |Block|.

Static Semantics: ContainsDuplicateLabels

With parameter _labelSet_.

Static Semantics: ContainsUndefinedBreakTarget

With parameter _labelSet_.

Static Semantics: ContainsUndefinedContinueTarget

With parameters _iterationSet_ and _labelSet_.

Static Semantics: VarDeclaredNames

Static Semantics: VarScopedDeclarations

Runtime Semantics: CatchClauseEvaluation

With parameter _thrownValue_.

Runtime Semantics: Evaluation

Runtime Semantics: Evaluation

Directive Prologues and the Use Strict Directive

A Directive Prologue is the longest sequence of |ExpressionStatement|s occurring as the initial |StatementListItem|s or |ModuleItem|s of a |FunctionBody|, a |ScriptBody|, or a |ModuleBody| and where each |ExpressionStatement| in the sequence consists entirely of a |StringLiteral| token followed by a semicolon. The semicolon may appear explicitly or may be inserted by automatic semicolon insertion. A Directive Prologue may be an empty sequence.

A Use Strict Directive is an |ExpressionStatement| in a Directive Prologue whose |StringLiteral| is either the exact code unit sequences `"use strict"` or `'use strict'`. A Use Strict Directive may not contain an |EscapeSequence| or |LineContinuation|.

A Directive Prologue may contain more than one Use Strict Directive. However, an implementation may issue a warning if this occurs.

Static Semantics: Early Errors

• If the source code matching this production is strict mode code, the Early Error rules for UniqueFormalParameters : FormalParameters are applied.
• If the source code matching this production is strict mode code, it is a Syntax Error if |BindingIdentifier| is present and the StringValue of |BindingIdentifier| is `"eval"` or `"arguments"`.
• It is a Syntax Error if ContainsUseStrict of |FunctionBody| is *true* and IsSimpleParameterList of |FormalParameters| is *false*.
• It is a Syntax Error if any element of the BoundNames of |FormalParameters| also occurs in the LexicallyDeclaredNames of |FunctionBody|.
• It is a Syntax Error if |FormalParameters| Contains |SuperProperty| is *true*.
• It is a Syntax Error if |FunctionBody| Contains |SuperProperty| is *true*.
• It is a Syntax Error if |FormalParameters| Contains |SuperCall| is *true*.
• It is a Syntax Error if |FunctionBody| Contains |SuperCall| is *true*.

• It is a Syntax Error if BoundNames of |FormalParameters| contains any duplicate elements.

• It is a Syntax Error if IsSimpleParameterList of |FormalParameterList| is *false* and BoundNames of |FormalParameterList| contains any duplicate elements.

• It is a Syntax Error if the LexicallyDeclaredNames of |FunctionStatementList| contains any duplicate entries.
• It is a Syntax Error if any element of the LexicallyDeclaredNames of |FunctionStatementList| also occurs in the VarDeclaredNames of |FunctionStatementList|.
• It is a Syntax Error if ContainsDuplicateLabels of |FunctionStatementList| with argument « » is *true*.
• It is a Syntax Error if ContainsUndefinedBreakTarget of |FunctionStatementList| with argument « » is *true*.
• It is a Syntax Error if ContainsUndefinedContinueTarget of |FunctionStatementList| with arguments « » and « » is *true*.

Static Semantics: BoundNames

Static Semantics: Contains

With parameter _symbol_.

Static Semantics: ContainsExpression

Static Semantics: ContainsUseStrict

Static Semantics: ExpectedArgumentCount

Static Semantics: HasInitializer

Static Semantics: HasName

Static Semantics: IsAnonymousFunctionDefinition ( _expr_ )

The abstract operation IsAnonymousFunctionDefinition determines if its argument is a function definition that does not bind a name. The argument _expr_ is the result of parsing an |AssignmentExpression| or |Initializer|. The following steps are taken:

Static Semantics: IsConstantDeclaration

Static Semantics: IsFunctionDefinition

Static Semantics: IsSimpleParameterList

Static Semantics: LexicallyDeclaredNames

Static Semantics: LexicallyScopedDeclarations

Static Semantics: VarDeclaredNames

Static Semantics: VarScopedDeclarations

Runtime Semantics: EvaluateBody

With parameters _functionObject_ and List _argumentsList_.

Runtime Semantics: IteratorBindingInitialization

With parameters _iteratorRecord_ and _environment_.

Runtime Semantics: InstantiateFunctionObject

With parameter _scope_.

Runtime Semantics: Evaluation

Static Semantics: Early Errors

• It is a Syntax Error if |ArrowParameters| Contains |YieldExpression| is *true*.
• It is a Syntax Error if |ArrowParameters| Contains |AwaitExpression| is *true*.
• It is a Syntax Error if ContainsUseStrict of |ConciseBody| is *true* and IsSimpleParameterList of |ArrowParameters| is *false*.
• It is a Syntax Error if any element of the BoundNames of |ArrowParameters| also occurs in the LexicallyDeclaredNames of |ConciseBody|.

• It is a Syntax Error if |CoverParenthesizedExpressionAndArrowParameterList| is not covering an |ArrowFormalParameters|.
• All early error rules for |ArrowFormalParameters| and its derived productions also apply to CoveredFormalsList of |CoverParenthesizedExpressionAndArrowParameterList|.

Static Semantics: BoundNames

Static Semantics: Contains

With parameter _symbol_.

Static Semantics: ContainsExpression

Static Semantics: ContainsUseStrict

Static Semantics: ExpectedArgumentCount

Static Semantics: HasName

Static Semantics: IsSimpleParameterList

Static Semantics: CoveredFormalsList

Static Semantics: LexicallyDeclaredNames

Static Semantics: LexicallyScopedDeclarations

Static Semantics: VarDeclaredNames

Static Semantics: VarScopedDeclarations

Runtime Semantics: IteratorBindingInitialization

With parameters _iteratorRecord_ and _environment_.

Runtime Semantics: EvaluateBody

With parameters _functionObject_ and List _argumentsList_.

Runtime Semantics: Evaluation

Static Semantics: Early Errors

• It is a Syntax Error if ContainsUseStrict of |FunctionBody| is *true* and IsSimpleParameterList of |UniqueFormalParameters| is *false*.
• It is a Syntax Error if any element of the BoundNames of |UniqueFormalParameters| also occurs in the LexicallyDeclaredNames of |FunctionBody|.

• It is a Syntax Error if BoundNames of |PropertySetParameterList| contains any duplicate elements.
• It is a Syntax Error if ContainsUseStrict of |FunctionBody| is *true* and IsSimpleParameterList of |PropertySetParameterList| is *false*.
• It is a Syntax Error if any element of the BoundNames of |PropertySetParameterList| also occurs in the LexicallyDeclaredNames of |FunctionBody|.

Static Semantics: ComputedPropertyContains

With parameter _symbol_.

Static Semantics: ExpectedArgumentCount

Static Semantics: HasDirectSuper

Static Semantics: PropName

Static Semantics: SpecialMethod

Runtime Semantics: DefineMethod

With parameters _object_ and optional parameter _functionPrototype_.

Runtime Semantics: PropertyDefinitionEvaluation

With parameters _object_ and _enumerable_.

Static Semantics: Early Errors

• It is a Syntax Error if HasDirectSuper of |GeneratorMethod| is *true*.
• It is a Syntax Error if |UniqueFormalParameters| Contains |YieldExpression| is *true*.
• It is a Syntax Error if ContainsUseStrict of |GeneratorBody| is *true* and IsSimpleParameterList of |UniqueFormalParameters| is *false*.
• It is a Syntax Error if any element of the BoundNames of |UniqueFormalParameters| also occurs in the LexicallyDeclaredNames of |GeneratorBody|.

• If the source code matching this production is strict mode code, the Early Error rules for UniqueFormalParameters : FormalParameters are applied.
• If the source code matching this production is strict mode code, it is a Syntax Error if |BindingIdentifier| is present and the StringValue of |BindingIdentifier| is `"eval"` or `"arguments"`.
• It is a Syntax Error if ContainsUseStrict of |GeneratorBody| is *true* and IsSimpleParameterList of |FormalParameters| is *false*.
• It is a Syntax Error if any element of the BoundNames of |FormalParameters| also occurs in the LexicallyDeclaredNames of |GeneratorBody|.
• It is a Syntax Error if |FormalParameters| Contains |YieldExpression| is *true*.
• It is a Syntax Error if |FormalParameters| Contains |SuperProperty| is *true*.
• It is a Syntax Error if |GeneratorBody| Contains |SuperProperty| is *true*.
• It is a Syntax Error if |FormalParameters| Contains |SuperCall| is *true*.
• It is a Syntax Error if |GeneratorBody| Contains |SuperCall| is *true*.

Static Semantics: BoundNames